{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
    "\n",
    "```shell\n",
    "pip install tensorflow\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-25T06:54:07.251409900Z",
     "start_time": "2024-07-25T06:53:57.265381800Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:37.672026Z",
     "iopub.status.busy": "2025-01-23T09:53:37.671673Z",
     "iopub.status.idle": "2025-01-23T09:53:37.678770Z",
     "shell.execute_reply": "2025-01-23T09:53:37.678267Z",
     "shell.execute_reply.started": "2025-01-23T09:53:37.672002Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备\n",
    "\n",
    "https://www.kaggle.com/competitions/cifar-10/data\n",
    "\n",
    "```shell\n",
    "$ tree -L 1 cifar-10                                    \n",
    "cifar-10\n",
    "├── sampleSubmission.csv\n",
    "├── test\n",
    "├── train\n",
    "└── trainLabels.csv\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-25T06:54:07.496010900Z",
     "start_time": "2024-07-25T06:54:07.256405800Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:41.563143Z",
     "iopub.status.busy": "2025-01-23T09:53:41.562769Z",
     "iopub.status.idle": "2025-01-23T09:53:43.864654Z",
     "shell.execute_reply": "2025-01-23T09:53:43.864142Z",
     "shell.execute_reply.started": "2025-01-23T09:53:41.563118Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(PosixPath('competitions/cifar-10/train/1.png'), 'frog'),\n",
      " (PosixPath('competitions/cifar-10/train/2.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/3.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/4.png'), 'deer'),\n",
      " (PosixPath('competitions/cifar-10/train/5.png'), 'automobile')]\n",
      "[(PosixPath('competitions/cifar-10/test/1.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/2.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/3.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/4.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/5.png'), 'cat')]\n",
      "50000 300000\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "DATA_DIR = Path(\".\")\n",
    "DATA_DIR1 =Path(\"competitions/cifar-10/\")\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\" #测试集模板csv文件\n",
    "train_folder = DATA_DIR1 / \"train\"\n",
    "test_folder = DATA_DIR1 / \"test\"\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "def parse_csv_file(filepath, folder):\n",
    "    \"\"\"Parses csv files into (filename(path), label) format\"\"\"\n",
    "    results = []\n",
    "    #读取所有行\n",
    "    with open(filepath, 'r') as f:\n",
    "#         lines = f.readlines()  为什么加[1:]，可以试这个\n",
    "        #第一行不需要，因为第一行是标签\n",
    "        lines = f.readlines()[1:] \n",
    "    for line in lines:#依次去取每一行\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "        results.append((image_full_path, label_str)) #得到对应图片的路径和分类\n",
    "    return results\n",
    "\n",
    "#解析对应的文件夹\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)\n",
    "#打印\n",
    "import pprint\n",
    "pprint.pprint(train_labels_info[0:5])\n",
    "pprint.pprint(test_csv_info[0:5])\n",
    "print(len(train_labels_info), len(test_csv_info))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:46.907846Z",
     "iopub.status.busy": "2025-01-23T09:53:46.907487Z",
     "iopub.status.idle": "2025-01-23T09:53:46.960468Z",
     "shell.execute_reply": "2025-01-23T09:53:46.959867Z",
     "shell.execute_reply.started": "2025-01-23T09:53:46.907811Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            filepath       class\n",
      "0  competitions/cifar-10/train/1.png        frog\n",
      "1  competitions/cifar-10/train/2.png       truck\n",
      "2  competitions/cifar-10/train/3.png       truck\n",
      "3  competitions/cifar-10/train/4.png        deer\n",
      "4  competitions/cifar-10/train/5.png  automobile\n",
      "                                filepath       class\n",
      "0  competitions/cifar-10/train/45001.png       horse\n",
      "1  competitions/cifar-10/train/45002.png  automobile\n",
      "2  competitions/cifar-10/train/45003.png        deer\n",
      "3  competitions/cifar-10/train/45004.png  automobile\n",
      "4  competitions/cifar-10/train/45005.png    airplane\n",
      "                           filepath class\n",
      "0  competitions/cifar-10/test/1.png   cat\n",
      "1  competitions/cifar-10/test/2.png   cat\n",
      "2  competitions/cifar-10/test/3.png   cat\n",
      "3  competitions/cifar-10/test/4.png   cat\n",
      "4  competitions/cifar-10/test/5.png   cat\n"
     ]
    }
   ],
   "source": [
    "# train_df = pd.DataFrame(train_labels_info)\n",
    "train_df = pd.DataFrame(train_labels_info[0:45000])\n",
    "valid_df = pd.DataFrame(train_labels_info[45000:])\n",
    "test_df = pd.DataFrame(test_csv_info)\n",
    "\n",
    "train_df.columns = ['filepath', 'class']\n",
    "valid_df.columns = ['filepath', 'class']\n",
    "test_df.columns = ['filepath', 'class']\n",
    "\n",
    "print(train_df.head())\n",
    "print(valid_df.head())\n",
    "print(test_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:50.559637Z",
     "iopub.status.busy": "2025-01-23T09:53:50.559288Z",
     "iopub.status.idle": "2025-01-23T09:53:50.567907Z",
     "shell.execute_reply": "2025-01-23T09:53:50.567280Z",
     "shell.execute_reply.started": "2025-01-23T09:53:50.559613Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "class Cifar10Dataset(Dataset):\n",
    "    df_map = {\n",
    "        \"train\": train_df,\n",
    "        \"eval\": valid_df,\n",
    "        \"test\": test_df\n",
    "    }\n",
    "    label_to_idx = {label: idx for idx, label in enumerate(class_names)} #将类别转换为数字\n",
    "    idx_to_label = {idx: label for idx, label in enumerate(class_names)}#将数字转换为类别\n",
    "    def __init__(self, mode, transform=None):\n",
    "        self.df = self.df_map.get(mode, None)\n",
    "        if self.df is None:\n",
    "            raise ValueError(\"mode should be one of train, val, test, but got {}\".format(mode))\n",
    "\n",
    "        self.transform = transform #对图片进行变换，transform是一个函数\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        img_path, label = self.df.iloc[index]#得到对应的图片路径和类别\n",
    "        img = Image.open(img_path).convert('RGB')#打开图片\n",
    "        # # img 转换为 channel first\n",
    "        # img = img.transpose((2, 0, 1))\n",
    "        # transform\n",
    "        img = self.transform(img) #对图片进行变换\n",
    "        # label 转换为 idx\n",
    "        label = self.label_to_idx[label]\n",
    "        return img, label #返回图片和类别\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.df.shape[0]\n",
    "    \n",
    "IMAGE_SIZE = 32\n",
    "mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n",
    "\n",
    "transforms_train = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        # random rotation 40\n",
    "        transforms.RandomRotation(40),\n",
    "        # horizaontal flip\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "transforms_eval = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "train_ds = Cifar10Dataset(\"train\", transforms_train)\n",
    "eval_ds = Cifar10Dataset(\"eval\", transforms_eval) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:53.110314Z",
     "iopub.status.busy": "2025-01-23T09:53:53.109972Z",
     "iopub.status.idle": "2025-01-23T09:53:53.113885Z",
     "shell.execute_reply": "2025-01-23T09:53:53.113255Z",
     "shell.execute_reply.started": "2025-01-23T09:53:53.110291Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=4)   \n",
    "eval_dl = DataLoader(eval_ds, batch_size=batch_size, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:48:48.383418Z",
     "iopub.status.busy": "2025-01-23T09:48:48.382980Z",
     "iopub.status.idle": "2025-01-23T09:48:48.385644Z",
     "shell.execute_reply": "2025-01-23T09:48:48.385207Z",
     "shell.execute_reply.started": "2025-01-23T09:48:48.383399Z"
    }
   },
   "outputs": [],
   "source": [
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "# def cal_mean_std(ds):\n",
    "#     mean = 0.\n",
    "#     std = 0.\n",
    "#     for img, _ in ds:\n",
    "#         mean += img.mean(dim=(1, 2))\n",
    "#         std += img.std(dim=(1, 2))\n",
    "#     mean /= len(ds)\n",
    "#     std /= len(ds)\n",
    "#     return mean, std\n",
    "#\n",
    "# # 经过 normalize 后 均值为0，方差为1\n",
    "# print(cal_mean_std(train_ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-25T07:01:50.235242700Z",
     "start_time": "2024-07-25T07:01:50.218212400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:56.740359Z",
     "iopub.status.busy": "2025-01-23T09:53:56.740003Z",
     "iopub.status.idle": "2025-01-23T09:53:56.753404Z",
     "shell.execute_reply": "2025-01-23T09:53:56.752851Z",
     "shell.execute_reply.started": "2025-01-23T09:53:56.740336Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 9216\n",
      "              model.5.bias              paramerters num: 32\n",
      "             model.7.weight             paramerters num: 9216\n",
      "              model.7.bias              paramerters num: 32\n",
      "            model.10.weight             paramerters num: 9216\n",
      "             model.10.bias              paramerters num: 32\n",
      "            model.12.weight             paramerters num: 9216\n",
      "             model.12.bias              paramerters num: 32\n",
      "               cls.weight               paramerters num: 5120\n",
      "                cls.bias                paramerters num: 10\n"
     ]
    }
   ],
   "source": [
    "class VGG(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Flatten(),\n",
    "        )\n",
    "        \n",
    "        self.cls = nn.Linear(512, num_classes)\n",
    "        \n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "                \n",
    "    @classmethod  #加载预训练   经过这个函数，模型的最后两层的参数还是随机初始化的\n",
    "    def from_pretrained(cls, ckpt_path, num_classes=10):\n",
    "        state_dict = torch.load(ckpt_path, map_location=\"cpu\") #加载模型参数\n",
    "        state_dict.pop(\"cls.weight\") #去掉最后一层的权重\n",
    "        state_dict.pop(\"cls.bias\") #去掉最后一层的偏置\n",
    "        \n",
    "        model = cls(num_classes=num_classes) #实例化模型\n",
    "        # 将修改后的状态字典加载到新创建的模型实例中。参数strict=False表示在加载状态字典时，如果字典中存在模型不期望的键或缺少某些期望的键，将不会抛出错误。这在迁移学习中很有用，因为你可能希望覆盖或忽略一些权重。\n",
    "        model.load_state_dict(state_dict, strict=False) #加载模型参数\n",
    "\n",
    "        return model\n",
    "        \n",
    "    def forward(self, x):\n",
    "        features = self.model(x)\n",
    "        return self.cls(features)\n",
    "        \n",
    "for key, value in VGG(len(class_names)).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-25T07:09:22.216355600Z",
     "start_time": "2024-07-25T07:09:22.205361600Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-23T09:53:59.070570Z",
     "iopub.status.busy": "2025-01-23T09:53:59.070250Z",
     "iopub.status.idle": "2025-01-23T09:53:59.077645Z",
     "shell.execute_reply": "2025-01-23T09:53:59.077087Z",
     "shell.execute_reply.started": "2025-01-23T09:53:59.070548Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 9216\n",
      "              model.5.bias              paramerters num: 32\n",
      "             model.7.weight             paramerters num: 9216\n",
      "              model.7.bias              paramerters num: 32\n",
      "            model.10.weight             paramerters num: 9216\n",
      "             model.10.bias              paramerters num: 32\n",
      "            model.12.weight             paramerters num: 9216\n",
      "             model.12.bias              paramerters num: 32\n",
      "               cls.weight               paramerters num: 5120\n",
      "                cls.bias                paramerters num: 10\n"
     ]
    }
   ],
   "source": [
    "model=VGG(len(class_names))\n",
    "print(type(model.named_parameters()))\n",
    "for key, value in  model.named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:54:01.889979Z",
     "iopub.status.busy": "2025-01-23T09:54:01.889630Z",
     "iopub.status.idle": "2025-01-23T09:54:01.895023Z",
     "shell.execute_reply": "2025-01-23T09:54:01.894363Z",
     "shell.execute_reply.started": "2025-01-23T09:54:01.889955Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:48:48.530399Z",
     "iopub.status.busy": "2025-01-23T09:48:48.530147Z",
     "iopub.status.idle": "2025-01-23T09:48:48.724477Z",
     "shell.execute_reply": "2025-01-23T09:48:48.723980Z",
     "shell.execute_reply.started": "2025-01-23T09:48:48.530379Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:54:05.530705Z",
     "iopub.status.busy": "2025-01-23T09:54:05.530359Z",
     "iopub.status.idle": "2025-01-23T09:54:05.536086Z",
     "shell.execute_reply": "2025-01-23T09:54:05.535561Z",
     "shell.execute_reply.started": "2025-01-23T09:54:05.530680Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:54:07.580706Z",
     "iopub.status.busy": "2025-01-23T09:54:07.580368Z",
     "iopub.status.idle": "2025-01-23T09:54:07.585176Z",
     "shell.execute_reply": "2025-01-23T09:54:07.584685Z",
     "shell.execute_reply.started": "2025-01-23T09:54:07.580683Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:54:15.410202Z",
     "iopub.status.busy": "2025-01-23T09:54:15.409889Z",
     "iopub.status.idle": "2025-01-23T09:55:35.477778Z",
     "shell.execute_reply": "2025-01-23T09:55:35.477201Z",
     "shell.execute_reply.started": "2025-01-23T09:54:15.410180Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7040/7040 [01:20<00:00, 87.94it/s, epoch=9] \n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 10\n",
    "model = VGG(num_classes=10) #第一次先训练，得到下面best.ckpt后，再注释这一条，用下面的加载模型\n",
    "\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "# Optimizers specified in the torch.optim package\n",
    "\n",
    "\n",
    "exp_name = \"vgg-fine-tune\"\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "# tensorboard_callback = TensorBoardCallback(f\"runs/{exp_name}\")\n",
    "# tensorboard_callback.draw_model(model, [1, 3, IMAGE_SIZE, IMAGE_SIZE])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "\n",
    "save_ckpt_callback = SaveCheckpointsCallback(f\"checkpoints/{exp_name}\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    eval_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:55:37.870248Z",
     "iopub.status.busy": "2025-01-23T09:55:37.869885Z",
     "iopub.status.idle": "2025-01-23T09:55:38.122305Z",
     "shell.execute_reply": "2025-01-23T09:55:38.121810Z",
     "shell.execute_reply.started": "2025-01-23T09:55:37.870218Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=100)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T09:55:56.552762Z",
     "iopub.status.busy": "2025-01-23T09:55:56.552386Z",
     "iopub.status.idle": "2025-01-23T09:55:57.222993Z",
     "shell.execute_reply": "2025-01-23T09:55:57.222401Z",
     "shell.execute_reply.started": "2025-01-23T09:55:56.552734Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.8509\n",
      "accuracy: 0.7098\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(f\"checkpoints/{exp_name}/best.ckpt\", weights_only=True,map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 微调"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-23T09:56:00.521915Z",
     "iopub.status.busy": "2025-01-23T09:56:00.521532Z",
     "iopub.status.idle": "2025-01-23T09:57:15.389648Z",
     "shell.execute_reply": "2025-01-23T09:57:15.389008Z",
     "shell.execute_reply.started": "2025-01-23T09:56:00.521890Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_369/2602895724.py:36: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  state_dict = torch.load(ckpt_path, map_location=\"cpu\") #加载模型参数\n",
      "100%|██████████| 7040/7040 [01:14<00:00, 94.05it/s, epoch=9] \n"
     ]
    }
   ],
   "source": [
    "model = VGG.from_pretrained(\"checkpoints/vgg-fine-tune/best.ckpt\", num_classes=10)   #加载预训练模型\n",
    "# 微调（Fine-tuning）：在迁移学习或微调预训练模型时，这种方法特别有用。在这种情况下，你可能希望对模型的预训练部分（不包含\"cls\"的部分）使用较小的学习率，以避免破坏已经学到的特征。而对新添加的或需要特别训练的部分（如新的分类层，包含\"cls\"的部分）使用较高的学习率，以便更快地学习到特定任务的特征。\n",
    "optimizer = torch.optim.Adam(\n",
    "    [\n",
    "        {\n",
    "            #卷积层\n",
    "            \"params\": [value for key, value in model.named_parameters() if \"cls\" not in key],\n",
    "            \"lr\": 0.0001 #卷积层用的是之前的预训练参数，不希望变化过大，所以学习率设为较小\n",
    "        },\n",
    "        {\n",
    "            #全连接层\n",
    "            \"params\": [value for key, value in model.named_parameters() if \"cls\" in key],\n",
    "            \"lr\": 0.0005 #分类层是重新初始化的，可以用较大的学习率\n",
    "        },\n",
    "     ]\n",
    "    )\n",
    "# 早停要重新初始化，不然再次训练会直接结束，因为早停里的counter已经=patience了,所以会直接结束。\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    eval_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 微调后评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-23T10:12:03.567414Z",
     "iopub.status.busy": "2025-01-23T10:12:03.567039Z",
     "iopub.status.idle": "2025-01-23T10:12:04.258308Z",
     "shell.execute_reply": "2025-01-23T10:12:04.257712Z",
     "shell.execute_reply.started": "2025-01-23T10:12:03.567375Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.7337\n",
      "accuracy: 0.7452\n"
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load(f\"checkpoints/{exp_name}/best.ckpt\",weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 推理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2025-01-23T09:48:49.323031Z",
     "iopub.status.idle": "2025-01-23T09:48:49.323250Z",
     "shell.execute_reply": "2025-01-23T09:48:49.323144Z",
     "shell.execute_reply.started": "2025-01-23T09:48:49.323134Z"
    }
   },
   "outputs": [],
   "source": [
    "# test_df\n",
    "# test_ds = Cifar10Dataset(\"test\", transform=transforms_eval)\n",
    "# test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, drop_last=False)\n",
    "#\n",
    "# preds_collect = []\n",
    "# model.eval()\n",
    "# for data, fake_label in tqdm(test_dl):\n",
    "#     data = data.to(device=device)\n",
    "#     logits = model(data)\n",
    "#     preds = [test_ds.idx_to_label[idx] for idx in logits.argmax(axis=-1).cpu().tolist()]\n",
    "#     preds_collect.extend(preds)\n",
    "#\n",
    "# test_df[\"class\"] = preds_collect\n",
    "# test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.status.busy": "2025-01-23T09:48:49.323746Z",
     "iopub.status.idle": "2025-01-23T09:48:49.323958Z",
     "shell.execute_reply": "2025-01-23T09:48:49.323864Z",
     "shell.execute_reply.started": "2025-01-23T09:48:49.323855Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 导出 submission.csv\n",
    "# test_df.to_csv(\"submission.csv\", index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
